package jeudame.Vue;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.ImageObserver;
import java.util.ArrayList;
import javax.swing.ImageIcon;
import javax.swing.JPanel;

/**
 * Class Monpanel: Le panel qui va être utilisé sur notre JFrame
 * @author Bilal et David
 */
public class Monpanel extends JPanel
{
    /**
     * Image du plateau
     * @see Monpanel#Monpanel(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
     */
    private Image Plateau = null;
    /**
     * Image du pion blanc
     * @see Monpanel#Monpanel(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
     */
    private Image PionBlanc = null;
    /**
     * Image du pion noir
     * @see Monpanel#Monpanel(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
     */
    private Image PionNoir = null;
    /**
     * Image de la dame blanche
     * @see Monpanel#Monpanel(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
     */
    private Image DameBlanche = null;
    /**
     * Image de la DameNoire
     * @see Monpanel#Monpanel(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
     */
    private Image DameNoire = null;

    /**
     * Nombre de pion blanc et noir
     * @see Monpanel#MiseAJourNb_pion(java.lang.String, int)
     */
    private int NbpionB=20;
    private int NbpionN=20;

    /**
     * Boolean pour centrer ou étirer l'image
     * @see Monpanel#setStretch(java.lang.Boolean)
     */
    private Boolean stretch = true;

    /**
     * Coordonnées des cases en bas à gauche et en haut à droite
     * @see  Monpanel#initVue()
     * @see Monpanel#PionMort(int, int)
     * @see Monpanel#TransformerDame(java.lang.String, int, int)
     */
    private int CaseBGaucheX= 194, CaseBGaucheY= 649; // Pour Y, l'image du pion se positionne en partant du haut gauche de celle-ci, nous sommes obligé d'enlever la taille d'une image (=case) en y pour bien la positionner 559 - 54 = 505

    /**
     * Intervalle x et y pour passer de case à case
     * @see Monpanel#initVue() 
     */
    private int TailleCaseX= 53, TailleCaseY= 54;

    /**
     * Boolean permettant de savoir si j'ai selectionné une pièce
     * @see Monpanel#GetCaseSelectionnee()
     * @see Monpanel#SetCaseSelectionnee(boolean)
     */
    private boolean PieceSelectionnee=false;

    /**
     * L'indice de la pièce sélectionnée
     * @see Monpanel#PieceSelection(int)
     * @see Monpanel#Deplacement(int, int, int)
     */
    private int IndicePieceSelection=-1;

    /**
     * Attribut du joueur
     * @see Monpanel#setJoueur(java.lang.String)
     */
    String TypeJoueur= "Joueur 1";

    /**
     * Une arrayliste de piece pour regrouper toutes les pièces du jeu, et y avoir accès
     * @see Monpanel#initVue()
     */
    ArrayList<ElementPieceVue> TableauPiece= new ArrayList<ElementPieceVue>();


    /**
     * Constructeur de Monpanel
     * @param filePlateau
     * @param filePionB
     * @param filePionN
     * @param fileDameB
     * @param fileDameN
     *      Les images qu'on utilisera
     */
    public Monpanel(String filePlateau, String filePionB, String filePionN, String fileDameB, String fileDameN)
    {
        this.Plateau = getToolkit().getImage(filePlateau);
        this.PionBlanc= getToolkit().getImage(filePionB);
        this.PionNoir= getToolkit().getImage(filePionN);
        this.DameBlanche= getToolkit().getImage(fileDameB);
        this.DameNoire= getToolkit().getImage(fileDameN);

        //Initialisation du tableau initial
        initVue();
    }

   /**
    * Position de l'image sur le panel
    * @param stretch true: etirer l'image / false: centrer l'image
    */
    public void setStretch(Boolean stretch) {
        this.stretch = stretch;
    }

    /**
     * Fonction qui intinialise l'interface globale
     * @see Monpanel#Monpanel(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
     */
    public void initVue()
    {
        TableauPiece.clear();

        //Initialisation du tableau initial
        for(int i=0; i<40; i++)
        {
            TableauPiece.add(new ElementPieceVue());
        }

        int numeroDePiece=0; // Va nous servir d'iterateur pour se déplacer dans le tableau de piece
        for(int i=0; i<10; i++)
        {
            for(int j=0; j<10; j++)
            {
                if(!((3<j) && (j<6))) // Sur un plateau de dame, il y a initialiement deux lignes ou il n'y à rien!
                {
                    if((i%2==0 && j%2==0)||(i%2==1 && j%2==1)) // (pair, pair)=> il y a une pièce, (impair, impair)=> il y a une pièce
                    {
                        if(j<4) // On est sur les pions Blancs
                        {
                            TableauPiece.get(numeroDePiece).setImage("Images"+java.io.File.separator+"Pion_Blanc.png");
                            TableauPiece.get(numeroDePiece).setPositionX((CaseBGaucheX + (i)*TailleCaseX));  // 53 = la distance x qu'il y a entre deux cases  54 = la distance y
                            TableauPiece.get(numeroDePiece).setPositionY((CaseBGaucheY -(j)*TailleCaseY));
                        }
                        else
                        {
                            TableauPiece.get(numeroDePiece).setImage("Images"+java.io.File.separator+"Pion_Noir.png");
                            TableauPiece.get(numeroDePiece).setPositionX((CaseBGaucheX + (i)*TailleCaseX));  // 53 = la distance x qu'il y a entre deux cases  54 = la distance y
                            TableauPiece.get(numeroDePiece).setPositionY((CaseBGaucheY -(j)*TailleCaseY));// 53 = la distance x qu'il y a entre deux cases  54 = la distance y
                        }
                        numeroDePiece++;
                    }
                    else
                    {
                        // (pair, impair) || (impair, pair) => il n'y a rien
                    }
                }
                else
                {
                    // On est sur les deux lignes ou il n'y à rien
                }
            }
        }
        //  Remise initiale des labels
        this.MiseAJourNb_pion("Blanc", 20);
        this.MiseAJourNb_pion("Noir", 20);
        this.setJoueur("Joueur 1");

        repaint();


    }

    /**
     * Surcharger la méthode d'affichage du panel
     * @param g canvas
     */
    @Override
    protected void paintComponent(Graphics g)

    {
        int x = 0;
        int y = 0;
        int width = 0;
        int height = 0;

        if (this.stretch) // Pour l'étirement de l'image
        {
            width = this.getWidth();
            height = this.getHeight();
        } else
        {
            width = this.Plateau.getWidth(this);
            height = this.Plateau.getHeight(this);
            x=((this.getWidth()-width)/2);
            y=((this.getHeight()-height)/2);
        }


        // On met en place notre plateau et nos pièces
        this.miseEnplace(g, x, y, width, height, this);


        // On écrit le nombre de pion Blanc
        g.setColor(Color.darkGray);
        g.setFont(new Font("Tahoma", Font.BOLD, 20));
        g.drawString(String.valueOf(NbpionB), 125, 490);

        // On écrit le nombre de pion Noir
        g.setColor(Color.darkGray);
        g.setFont(new Font("Tahoma", Font.BOLD, 20));
        g.drawString(String.valueOf(NbpionN), 125, 550);

        //Mise en place du noms du joueur
        g.drawString(TypeJoueur, 30, 315);

    }

    /**
     * Fonction qui met à jour le joueur
     * @param TypeJ
     *          Le type du joueur
     */
    public void setJoueur(String TypeJ)
    {
        this.TypeJoueur= TypeJ;
    }

    /**
     * Fonction permettant de savoir quelle pièce est sélectionnée
     * @param Indice
     *          L'indice de la pièce dans le tableau
     */
    public void PieceSelection(int Indice)
    {
        this.IndicePieceSelection= Indice;
    }

    /**
     * Renvoi le type d'image de la piece selectionnée, si c'est un pion blanc, pion noir, dame blanche, dame noire
     * @param Indice
     * @return Le type d'image (string) de la pièce selectionnée
     */
    public String RenvoiImagePiece(int Indice)
    {
        return TableauPiece.get(Indice-1).getImage();
    }

    /**
     * Renvoi la position x de la piece selectionnée
     * @param Indice
     * @return La position X de la pièce du tableau à l'indice Indice
     */
    public int getPiecePositionX(int Indice)
    {
        return TableauPiece.get(Indice-1).getPositionX();
    }

    /**
     * Renvoi la position y de la piece selectionnée
     * @param Indice
     * @return La position Y de la pièce du tableau à l'indice Indice
     */
    public int getPiecePositionY(int Indice)
    {
        return TableauPiece.get(Indice-1).getPositionY();
    }

    /**
     * Fonction qui va confirmer à la vue, que l'on a bien fais le clique (Utilie pour selectionner la piece en rouge)
     * @param selection
     *          Boolean permettant de savoir si une pièce est selectionnée
     */
    public void SetCaseSelectionnee(boolean selection)
    {
        this.PieceSelectionnee= selection;
    }

    /**
     * Renvoi un boolean qui nous affirme si la pièce est sélectionnée
     * @return
     *      Le boolean de la pièce selectionnée
     */
    public boolean GetCaseSelectionnee()
    {
        return PieceSelectionnee;
    }

    /**
     * Fonction qui met en place le plateau et les pièces sur le plateau de jeu (images)
     * @param g
     * @param x
     * @param y
     * @param width
     * @param height
     * @param io
     *      Ces paramètres vont permettrent de mettre en place l'interface graphique
     */
    public void miseEnplace(Graphics g, int x, int y, int width, int height, ImageObserver io)
    {
        /**
         * Mise en place du plateau de jeu
         */
        g.drawImage(this.Plateau, x, y, width, height, this); // On dessine le plateau sur le Panel

        /**
         * Selectionne une pièce
         * A cet endroit pour être au dessus du plateau et être en dessous de la pièce
         */
         if(PieceSelectionnee)
            SelectionnerPiece(g, IndicePieceSelection);

        /**
         * Mise en place des pions Blancs et Noirs sur le plateau
         */
        for(int i=0; i<TableauPiece.size(); i++)
        {
            g.drawImage(new ImageIcon(this.TableauPiece.get(i).getImage()).getImage(), this.TableauPiece.get(i).getPositionX(), this.TableauPiece.get(i).getPositionY()-TailleCaseY, io); // TailleCaseX = la distance y entre une case et une autre
        }
    }

     /**
     * Fonction qui va nous permettre de déplacer les images pieces sur le plateau de jeu
      * @param IndiceDepart 
      * @param CaseArriveeX
     * @param CaseArriveeY
      *           Les positions X et Y de départ et d'arrivée
     */
    public void Deplacement(int IndiceDepart, int CaseArriveeX, int CaseArriveeY) // Faire l'animation dans le controleur, en appellant cette fonction dans une boucle
    {
        IndicePieceSelection= IndiceDepart;

        // Modification des positions x et y
        TableauPiece.get(IndiceDepart-1).setPositionX(CaseArriveeX);
        TableauPiece.get(IndiceDepart-1).setPositionY(CaseArriveeY);
    }

    /**
     * Fonction qui va rechercher une pièce grâce aux position X et Y en paramètre, et une fois trouvée, elle retourne l'indice de celle-ci
     * @param MouseClickX
     * @param MouseClickY
     * @return Le numéro de pièce qui a été trouvée
     */
    public int RecherchePiece(int MouseClickX, int MouseClickY)
    {
        int temp=0; // Va récupérer notre numéro de pièce
        for(int i=0; i<40; i++)
        {
            //if(TabIntervalle[0][i] <= MouseClickX && TabIntervalle[2][i] >= MouseClickX && TabIntervalle[1][i] >= MouseClickY && TabIntervalle[3][i] <= MouseClickY)
            if(TableauPiece.get(i).getPositionX()<= MouseClickX && TableauPiece.get(i).getPositionX()+TailleCaseX >= MouseClickX && TableauPiece.get(i).getPositionY() >= MouseClickY && TableauPiece.get(i).getPositionY()-TailleCaseY <= MouseClickY)
                return i+1; // +1 car la première pièce est la numéro 0
            else{
                temp = -1; // Cela voudra dire que l'utilisateur n'a pas cliquer sur une case du plateau
            }
        }
        return temp;// On sort avec temp = 1, donc on n'a pas trouvé la pièce
    }

    /**
     * Fonction qui va nous permettre de dessiner un rectangle autour de la pièce selectionnée
     * L'appel se fait dans la mise en place du plateau
     * @param g
     * @param Indice
     */
    public void SelectionnerPiece(Graphics g, int Indice)
    {
        g.setColor(Color.red);
        // -54: car le rectangle se dessine à partir du point en haut à gauche de la case
        g.fillRect(TableauPiece.get(Indice-1).getPositionX(), TableauPiece.get(Indice-1).getPositionY()-TailleCaseY, TailleCaseX, TailleCaseY);
    }

    /**
     * Foncton qui va rendre un pion mort, en modifiant sa position
     * @param PositionX
     * @param PositionY
     *         Position X et Y de la pièce à supprimer
     */
    public void PionMort(int PositionX, int PositionY)
    {
        // Modification de position
        TableauPiece.get(RecherchePiece(PositionX*TailleCaseX+CaseBGaucheX+1, ((CaseBGaucheY)-PositionY*TailleCaseY))-1).setPositionX(-100);
        TableauPiece.get(RecherchePiece(-100, ((CaseBGaucheY)-PositionY*TailleCaseY))-1).setPositionY(-100);

        repaint();
    }

    /**
     * Fonction qui va rendre un pion en dame
     * @param TypeDame
     * @param PositionX
     * @param PositionY
     *         Position X et Y de la pièce à transformer en Dame
     */
    public void TransformerDame(String TypeDame, int PositionX, int PositionY)
    {
         // On teste si le pion est noir, et donc on le transforme en dame noire
         System.out.println("Dame a transformer: x="+PositionX + "y= " + PositionY);
         System.out.println("Indice Piece :"+ (RecherchePiece(PositionX*TailleCaseX+195, ((649)-PositionY*TailleCaseY))-1));
         System.out.println("DEBUG : TransformerDame CaseBGaucheX="+CaseBGaucheX+" CaseBGaucheY=" + CaseBGaucheY);
         // On teste si le pion est noir, et donc on le transforme en dame noire
        if(TypeDame.equalsIgnoreCase("Noir"))
        {
            TableauPiece.get(RecherchePiece(PositionX*53+CaseBGaucheX+1, ((CaseBGaucheY)-PositionY*54))-1).setImage("Images"+java.io.File.separator+"Pion_Noir_Dame.png");
        }
        if(TypeDame.equalsIgnoreCase("Blanc")){
            TableauPiece.get(RecherchePiece(PositionX*53+CaseBGaucheX+1, ((CaseBGaucheY)-PositionY*54))-1).setImage("Images"+java.io.File.separator+"Pion_Blanc_Dame.png");
        }

        this.repaint();
    }

    /**
     * Fonction qui met à jour le nombre de pion
     * On le mettra à jour à la suite sur l'interface graphique
     * @param TypePion
     * @param Nb_pion
     */
    public void MiseAJourNb_pion(String TypePion, int Nb_pion)
    {
        if(TypePion.equalsIgnoreCase("Blanc"))
        {
            NbpionB= Nb_pion;
        }
        else
        {
           NbpionN= Nb_pion;
        }
    }
}